home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / bbs / fraction / ffrsrc.exe / UNIX.C < prev    next >
C/C++ Source or Header  |  1991-11-13  |  5KB  |  224 lines
  1. /*
  2. *** FFR by DG1BBQ@DB0CL.DEU.EU
  3. ***
  4. *** unix.c
  5. ***
  6.  */
  7.  
  8. #include "ffr.h"
  9. /*--------------------------------*\
  10. | Additions for UNIX-compatibility |
  11. \*--------------------------------*/
  12. #ifdef __unix__
  13.  
  14. #ifdef __vax__
  15. char *strdup(s1)
  16.   char *s1;
  17. { char *s;
  18.  
  19.   s = malloc(strlen(s1)+1);
  20.   strcpy(s,s1);
  21. }
  22. #endif
  23.  
  24. static int first = 1;
  25.  
  26. int my_getch()
  27. { unsigned char c;
  28.   int fd;
  29.  
  30.   fd = fileno (stdin);
  31.   if (first) {
  32.     first = 0;
  33. #ifdef SYSV
  34.     (void) ioctl(fd, TCGETA, (char *) &sg[OFF]);
  35. #else
  36.     (void) gtty(fd, &sg[OFF]);
  37. #endif
  38.     sg[ON] = sg[OFF];
  39.  
  40. #ifdef SYSV
  41.     sg[ON].c_lflag &= ~(ICANON|ECHO);
  42.     sg[ON].c_cc[VMIN] = 1;
  43.     sg[ON].c_cc[VTIME] = 0;
  44. #else
  45.     sg[ON].sg_flags &= ~(ECHO | CRMOD);
  46.     sg[ON].sg_flags |= CBREAK;
  47. #endif
  48.   }
  49.  
  50. #ifdef SYSV
  51.   (void) ioctl(fd, TCSETAW, (char *) &sg[ON]);
  52. #else
  53.   (void) stty(fd, &sg[ON]);
  54. #endif
  55.  
  56.   read(fd, &c, 1);
  57.  
  58. #ifdef SYSV
  59.   (void) ioctl(fd, TCSETAW, (char *) &sg[OFF]);
  60. #else
  61.   (void) stty(fd, &sg[OFF]);
  62. #endif
  63.  
  64.   return (int) c;
  65.  }
  66.  
  67. #ifdef __i386__
  68. #define MAXCMD 1024
  69.  
  70. int rename(char const *s1, const char *s2)
  71. {
  72.     char tmp[MAXCMD];
  73.  
  74.     (void) sprintf(tmp, "mv %s %s", s1, s2);
  75.     (void) system(tmp);
  76. }
  77.  
  78. /*
  79.     strstr - public-domain implementation of standard C library function
  80.  
  81.     last edit:    02-Sep-1990    D A Gwyn
  82.  
  83.     This is an original implementation based on an idea by D M Sunday,
  84.     essentially the "quick search" algorithm described in CACM V33 N8.
  85.     Unlike Sunday's implementation, this one does not wander past the
  86.     ends of the strings (which can cause malfunctions under certain
  87.     circumstances), nor does it require the length of the searched
  88.     text to be determined in advance.  There are numerous other subtle
  89.     improvements too.  The code is intended to be fully portable, but in
  90.     environments that do not conform to the C standard, you should check
  91.     the sections below marked "configure as required".  There are also
  92.     a few compilation options, as follows:
  93.  
  94.     #define ROBUST    to obtain sane behavior when invoked with a null
  95.             pointer argument, at a miniscule cost in speed
  96.     #define ZAP    to use memset() to zero the shift[] array; this may
  97.             be faster in some implementations, but could fail on
  98.             unusual architectures
  99.     #define DEBUG    to enable assertions (bug detection)
  100. */
  101. #define ROBUST
  102. #define    ZAP
  103.  
  104. #ifdef __STDC__
  105.  
  106. #include    <limits.h>        /* defines UCHAR_MAX */
  107.  
  108. #ifdef ZAP
  109. typedef void    *pointer;
  110. extern pointer    memset( pointer, int, size_t );
  111. #endif
  112.  
  113. #else    /* normal UNIX-like C environment assumed; configure as required: */
  114.  
  115. #ifndef NULL
  116. #define    NULL        0        /* null pointer constant */
  117. #endif
  118.  
  119. #define    UCHAR_MAX    255        /* largest value of unsigned char */
  120.                     /* 255 @ 8 bits, 65535 @ 16 bits */
  121.  
  122. #ifdef ZAP
  123. typedef char    *pointer;
  124. extern pointer    memset();
  125. #endif
  126.  
  127. #endif    /* __STDC__ */
  128.  
  129. #ifndef DEBUG
  130. #define    NDEBUG
  131. #endif
  132. #include    <assert.h>
  133.  
  134. typedef const unsigned char    cuc;    /* char variety used in algorithm */
  135.  
  136. #define EOS    '\0'            /* C string terminator */
  137.  
  138. char *                    /* returns -> leftmost occurrence,
  139.                    or null pointer if not present */
  140. strstr( s1, s2 )
  141.     const char    *s1;              /* -> string to be searched */
  142.     const char    *s2;        /* -> search-pattern string */
  143.     {
  144.     register cuc    *t;          /* -> text character being tested */
  145.     register cuc    *p;          /* -> pattern char being tested */
  146.     register cuc    *tx;        /* -> possible start of match */
  147.     register size_t    m;        /* length of pattern */
  148.     register cuc    *top;        /* -> high water mark in text */
  149. #if UCHAR_MAX > 255            /* too large for auto allocation */
  150.     static                /* not malloc()ed; that can fail! */
  151. #endif                    /* else allocate shift[] on stack */
  152.         size_t    shift[UCHAR_MAX + 1];    /* pattern shift table */
  153.  
  154. #ifdef ROBUST                /* not required by C standard */
  155.     if ( s1 == NULL || s2 == NULL )
  156.         return NULL;        /* certainly, no match is found! */
  157. #endif
  158.  
  159.     /* Precompute shift intervals based on the pattern;
  160.        the length of the pattern is determined as a side effect: */
  161.  
  162. #ifdef ZAP
  163.     (void)memset( (pointer)&shift[1], 0, UCHAR_MAX * sizeof(size_t) );
  164. #else
  165.     {
  166.     register unsigned char    c;
  167.  
  168.     c = UCHAR_MAX;
  169.     do
  170.         shift[c] = 0;
  171.     while ( --c > 0 );
  172.     }
  173. #endif
  174.       /* Note: shift[0] is undefined at this point (fixed later). */
  175.  
  176.   for ( m = 1, p = (cuc *)s2; *p != EOS; ++m, ++p )
  177.       shift[(cuc)*p] = m;
  178.  
  179.     assert(s2[m - 1] == EOS);
  180.  
  181.      {
  182.     register unsigned char    c;
  183.  
  184.      c = UCHAR_MAX;
  185.      do
  186.          shift[c] = m - shift[c];
  187.      while ( --c > 0 );
  188.  
  189.      /* Note: shift[0] is still undefined at this point. */
  190.      }
  191.  
  192.      shift[0] = --m;         /* shift[EOS]; important details! */
  193.  
  194.      assert(s2[m] == EOS);
  195.  
  196.      /* Try to find the pattern in the text string: */
  197.  
  198.      for ( top = tx = (cuc *)s1; ; tx += shift[*(top = t)] )
  199.          {
  200.          for ( t = tx, p = (cuc *)s2; ; ++t, ++p )
  201.              {
  202.              if ( *p == EOS )       /* entire pattern matched */
  203.                  return (char *)tx;
  204.  
  205.              if ( *p != *t )
  206.                  break;
  207.              }
  208.  
  209.          if ( t < top )        /* idea due to ado@elsie.nci.nih.gov */
  210.              t = top;    /* already scanned this far for EOS */
  211.  
  212.          do    {
  213.              assert(m > 0);
  214.              assert(t - tx < m);
  215.  
  216.              if ( *t == EOS )
  217.                  return NULL;    /* no match */
  218.              }
  219.          while ( ++t - tx != m );    /* < */
  220.          }
  221.      }
  222. #endif
  223. #endif
  224.